PC for Alla 2005 May/PC för Alla 0505.iso/fullversioner/realsoft3d/data1.cab/Scripting/scripts/js/real/raytr/r3surf.js

JavaScript | 2005-04-04 | 11.2 KB | 417 lines

// JavaScript wrapper for r3surf.h
// Auto generated file, do not modify by hand
// Copyright ⌐ 2004, Realsoft Graphics Oy

var R3_SURFACE_H = 1;
include("real/raytr/r3frsurf.js")
include("oops/r3vector.js")
include("real/frio/r3raysmp.js")


var R3CLID_SURFACE = 406;




// Description: General rayhit finder. Ray position & direction can be arbitrary.
// Virtual method

R3SURFM_RAYHIT = 406000;

function mR3SURFM_RAYHIT() {
  DoA(this.r3obj, 406000, 0, R3TID_INTEGER, 0);
}

// Description: Perspective camera rayhit finder (ray source position = (0,0,0)).    * Only hits greater than RHITMSG->mindist
//      are accepted.
// Virtual method

R3SURFM_RAYHITOPT = 406001;

function mR3SURFM_RAYHITOPT() {
  DoA(this.r3obj, 406001, 0, R3TID_INTEGER, 0);
}

// Description: Same as above, but this method is called if the surface is known to
//      be fully in front of the camera.
// Virtual method

R3SURFM_RAYHITOPTM = 406002;

function mR3SURFM_RAYHITOPTM() {
  DoA(this.r3obj, 406002, 0, R3TID_INTEGER, 0);
}

// Description: Parallel camera rayhit finder (ray dir = (0,0,1), ray source = (x,y,0) ).    * Only
//      hits greater than RHITMSG->mindist are accepted.
// Virtual method

R3SURFM_AXHITOPT = 406003;

function mR3SURFM_AXHITOPT() {
  DoA(this.r3obj, 406003, 0, R3TID_INTEGER, 0);
}

// Description: general light ray finder.    * All hits closer than RHITMSG->nrsthit->dist should be processed.
// Virtual method

R3SURFM_LIGHTHIT = 406004;

function mR3SURFM_LIGHTHIT() {
  DoA(this.r3obj, 406004, 0, R3TID_INTEGER, 0);
}

// Description: light rayhit finder (all light rays originate from the same position).    * All hits closer
//      than RHITMSG->nrsthit->dist should be processed.
// Virtual method

R3SURFM_LIGHTHITOPT = 406005;

function mR3SURFM_LIGHTHITOPT() {
  DoA(this.r3obj, 406005, 0, R3TID_INTEGER, 0);
}

// Description: Same as above, but this method is called if the surface is known to
//      be fully in front of the light ray origin at the direction of the given
//      ray (e.g. when the ray is cast by an optimized spot light).
// Virtual method

R3SURFM_LIGHTHITOPTM = 406006;

function mR3SURFM_LIGHTHITOPTM() {
  DoA(this.r3obj, 406006, 0, R3TID_INTEGER, 0);
}


R3SURFM_TRIM = 406007;

function mR3SURFM_TRIM() {
  DoA(this.r3obj, 406007, 0, R3TID_INTEGER, 0);
}


R3SURFM_AXTRIM = 406008;

function mR3SURFM_AXTRIM() {
  DoA(this.r3obj, 406008, 0, R3TID_INTEGER, 0);
}


R3SURFM_ORIGTRIM = 406009;

function mR3SURFM_ORIGTRIM() {
  DoA(this.r3obj, 406009, 0, R3TID_INTEGER, 0);
}

// Description: Evaluates properties in a point on the surface

R3SURFM_EVALUATESURFACEPOINT = 406010;

function mR3SURFM_EVALUATESURFACEPOINT() {
  DoA(this.r3obj, 406010, 0, R3TID_INTEGER, 0);
}

// Description: Evaluate only UV channel
// p3: r3Vect, result UV coords

R3SURFM_EVALUATEUV = 406011;

function mR3SURFM_EVALUATEUV(p3) {
  DoA(this.r3obj, 406011, p3, R3TID_VECTOR, 0);
}

// Description: Surface visibility check for perspective camera rays from origin. Note that ray * tracer
//      optimizes bounding sphere, bounding box etc. visibility so only very object specific * visibility properties
//      should be optimized here.
// p2: Object, pointer to a temp memory buffer (size = R3SURFCA_MaxPosdatasize defined by this class). *
//      Store temporary values here to avoid time consuming recomputation later at ALLOCPOSDATA
// p3: Tag[], tag list includes R3SURFA_OptDataVector vector tag defining

R3SURFM_QUERYPOSDATA = 406012;

function mR3SURFM_QUERYPOSDATA(p2, p3) {
  Do3(this.r3obj, 406012, 0, R3TID_INTEGER, 0, p2, R3TID_OBJECT, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}


R3SURFM_QUERYAXDATA = 406013;

function mR3SURFM_QUERYAXDATA() {
  DoA(this.r3obj, 406013, 0, R3TID_INTEGER, 0);
}


R3SURFM_QUERYSHADOWDATA = 406014;

function mR3SURFM_QUERYSHADOWDATA() {
  DoA(this.r3obj, 406014, 0, R3TID_INTEGER, 0);
}

// Description: Initialize optimization data for perspective camera ray hits p1: void *, the temp memory
//      buffer that was available as p2 parameyter in R3SURFM_QUERYPOSDATA p2: R3POSDATA *, the optimization data
//      to be initialized. You can put temporary values that depend on the surface and ray
//      hit source position here to avoid repeating computation at rendering time. Rc: geometrical complexity estimate-
//      see defs below

R3SURFM_INITPOSDATA = 406015;

function mR3SURFM_INITPOSDATA() {
  DoA(this.r3obj, 406015, 0, R3TID_INTEGER, 0);
}


R3SURFM_INITAXDATA = 406016;

function mR3SURFM_INITAXDATA() {
  DoA(this.r3obj, 406016, 0, R3TID_INTEGER, 0);
}


R3SURFM_INITSHADOWDATA = 406017;

function mR3SURFM_INITSHADOWDATA() {
  DoA(this.r3obj, 406017, 0, R3TID_INTEGER, 0);
}


R3SURFCM_REGISTERCACHECLASS = 406018;

function mR3SURFCM_REGISTERCACHECLASS() {
  DoA(this.r3obj, 406018, 0, R3TID_INTEGER, 0);
}


R3SURFCM_CREATECACHE = 406019;

function mR3SURFCM_CREATECACHE() {
  DoA(this.r3obj, 406019, 0, R3TID_INTEGER, 0);
}


R3SURFCM_DELETECACHE = 406020;

function mR3SURFCM_DELETECACHE() {
  DoA(this.r3obj, 406020, 0, R3TID_INTEGER, 0);
}


R3SURFCM_RESETCACHE = 406021;

function mR3SURFCM_RESETCACHE() {
  DoA(this.r3obj, 406021, 0, R3TID_INTEGER, 0);
}


R3SURFCM_ALLOCCACHE = 406022;

function mR3SURFCM_ALLOCCACHE() {
  DoA(this.r3obj, 406022, 0, R3TID_INTEGER, 0);
}


R3SURFCM_FREECACHE = 406023;

function mR3SURFCM_FREECACHE() {
  DoA(this.r3obj, 406023, 0, R3TID_INTEGER, 0);
}


R3SURFCM_INITCACHE = 406024;

function mR3SURFCM_INITCACHE() {
  DoA(this.r3obj, 406024, 0, R3TID_INTEGER, 0);
}


R3SURFM_GETHOLLOWNESS = 406025;

function mR3SURFM_GETHOLLOWNESS() {
  DoA(this.r3obj, 406025, 0, R3TID_INTEGER, 0);
}

// Description: Increases cache counter so that next time when cache is needed, it is recreated
//      to    * take account the new situation. Example: When a new max point count is detected
//      in CREATE method,    * class sends this message to surface base class.

R3SURFCM_INCREASECACHE = 406026;

function mR3SURFCM_INCREASECACHE() {
  DoA(this.r3obj, 406026, 0, R3TID_INTEGER, 0);
}

// Description: Evaluates properties in two near points of the ray hit point. * R3SURFM_EVALUATESURFACEPOINT is
//      always called before use of this method.
// p2: Object, u direction raysample initialized by R3SURFM_EVALUATESURFACEPOINT
// p3: Object, v direction raysample initialized by R3SURFM_EVALUATESURFACEPOINT

R3SURFM_EVALUATEDERIVATE = 406027;

function mR3SURFM_EVALUATEDERIVATE(p2, p3) {
  DoA3(this.r3obj, 406027, 0, R3TID_INTEGER, 0, p2, R3TID_OBJECT, 0, p3, R3TID_OBJECT, 0);
}


R3SURFM_NOSHADOWS = 406028;

function mR3SURFM_NOSHADOWS() {
  DoA(this.r3obj, 406028, 0, R3TID_INTEGER, 0);
}


R3SURFM_GETEXTFLAGS = 406029;

function mR3SURFM_GETEXTFLAGS() {
  DoA(this.r3obj, 406029, 0, R3TID_INTEGER, 0);
}


R3SURFM_SETEXTFLAGS = 406030;

function mR3SURFM_SETEXTFLAGS() {
  DoA(this.r3obj, 406030, 0, R3TID_INTEGER, 0);
}




R3SURFA_Radius = 406500;
function SetR3SURFA_Radius(value) {
  R3Set(this.r3obj, R3SURFA_Radius, value, R3TID_FLOAT, 0);
}

function GetR3SURFA_Radius() {
  return R3Get(this.r3obj, R3SURFA_Radius, R3TID_FLOAT, 0);
}

R3SURFA_Mask = 406501;
function SetR3SURFA_Mask(value) {
  R3Set(this.r3obj, R3SURFA_Mask, value, R3TID_VECTOR, R3TNF_ARRAY);
}

function GetR3SURFA_Mask() {
  return R3Get(this.r3obj, R3SURFA_Mask, R3TID_VECTOR, R3TNF_ARRAY);
}

R3SURFA_MaskPoints = 406502;
function SetR3SURFA_MaskPoints(value) {
  R3Set(this.r3obj, R3SURFA_MaskPoints, value, R3TID_INTEGER, 0);
}

function GetR3SURFA_MaskPoints() {
  return R3Get(this.r3obj, R3SURFA_MaskPoints, R3TID_INTEGER, 0);
}

R3SURFA_Cog = 406503;
function GetR3SURFA_Cog() {
  return R3Get(this.r3obj, R3SURFA_Cog, R3TID_VECTOR, 0);
}

R3SURFA_Parent = 406504;
function SetR3SURFA_Parent(value) {
  R3Set(this.r3obj, R3SURFA_Parent, value, R3TID_OBJECT, 0);
}

function GetR3SURFA_Parent() {
  return R3ToJS(R3Get(this.r3obj, R3SURFA_Parent, R3TID_OBJECT, 0));
}

R3SURFA_Trim = 406505;
function SetR3SURFA_Trim(value) {
  R3Set(this.r3obj, R3SURFA_Trim, value, R3TID_OBJECT, 0);
}

function GetR3SURFA_Trim() {
  return R3ToJS(R3Get(this.r3obj, R3SURFA_Trim, R3TID_OBJECT, 0));
}

R3SURFA_InvertUVTrim = 406513;
function SetR3SURFA_InvertUVTrim(value) {
  R3Set(this.r3obj, R3SURFA_InvertUVTrim, value, R3TID_INTEGER, 0);
}

R3SURFA_TrimOperation = 406530;
function SetR3SURFA_TrimOperation(value) {
  R3Set(this.r3obj, R3SURFA_TrimOperation, value, R3TID_INTEGER, 0);
}

R3SURFA_InvertNormal = 406534;
function SetR3SURFA_InvertNormal(value) {
  R3Set(this.r3obj, R3SURFA_InvertNormal, value, R3TID_INTEGER, 0);
}

function GetR3SURFA_InvertNormal() {
  return R3Get(this.r3obj, R3SURFA_InvertNormal, R3TID_INTEGER, 0);
}

R3SURFA_Complexity = 406536;
function GetR3SURFA_Complexity() {
  return R3Get(this.r3obj, R3SURFA_Complexity, R3TID_INTEGER, 0);
}

var R3FRSURF_UVOP_XOR = 0;
var R3FRSURF_UVOP_AND = 1;
var R3FRSURF_UVOP_OR = 2;
var R3SURFPR_PERSPECTIVE = 0;
var R3SURFPR_ORTHOGRAPHIC = 1;


function r3Surface () {
   this.base = r3God;
   if(arguments.length) {
      this.base(R3CLID_SURFACE, arguments);
   }
   // Methods
   this.RAYHIT=mR3SURFM_RAYHIT;
   this.RAYHITOPT=mR3SURFM_RAYHITOPT;
   this.RAYHITOPTM=mR3SURFM_RAYHITOPTM;
   this.AXHITOPT=mR3SURFM_AXHITOPT;
   this.LIGHTHIT=mR3SURFM_LIGHTHIT;
   this.LIGHTHITOPT=mR3SURFM_LIGHTHITOPT;
   this.LIGHTHITOPTM=mR3SURFM_LIGHTHITOPTM;
   this.TRIM=mR3SURFM_TRIM;
   this.AXTRIM=mR3SURFM_AXTRIM;
   this.ORIGTRIM=mR3SURFM_ORIGTRIM;
   this.EVALUATESURFACEPOINT=mR3SURFM_EVALUATESURFACEPOINT;
   this.EVALUATEUV=mR3SURFM_EVALUATEUV;
   this.QUERYPOSDATA=mR3SURFM_QUERYPOSDATA;
   this.QUERYAXDATA=mR3SURFM_QUERYAXDATA;
   this.QUERYSHADOWDATA=mR3SURFM_QUERYSHADOWDATA;
   this.INITPOSDATA=mR3SURFM_INITPOSDATA;
   this.INITAXDATA=mR3SURFM_INITAXDATA;
   this.INITSHADOWDATA=mR3SURFM_INITSHADOWDATA;
   this.REGISTERCACHECLASS=mR3SURFCM_REGISTERCACHECLASS;
   this.CREATECACHE=mR3SURFCM_CREATECACHE;
   this.DELETECACHE=mR3SURFCM_DELETECACHE;
   this.RESETCACHE=mR3SURFCM_RESETCACHE;
   this.ALLOCCACHE=mR3SURFCM_ALLOCCACHE;
   this.FREECACHE=mR3SURFCM_FREECACHE;
   this.INITCACHE=mR3SURFCM_INITCACHE;
   this.GETHOLLOWNESS=mR3SURFM_GETHOLLOWNESS;
   this.INCREASECACHE=mR3SURFCM_INCREASECACHE;
   this.EVALUATEDERIVATE=mR3SURFM_EVALUATEDERIVATE;
   this.NOSHADOWS=mR3SURFM_NOSHADOWS;
   this.GETEXTFLAGS=mR3SURFM_GETEXTFLAGS;
   this.SETEXTFLAGS=mR3SURFM_SETEXTFLAGS;

   // Attributes
   this.GetRadius=GetR3SURFA_Radius;
   this.SetRadius=SetR3SURFA_Radius;
   this.GetMask=GetR3SURFA_Mask;
   this.SetMask=SetR3SURFA_Mask;
   this.GetMaskPoints=GetR3SURFA_MaskPoints;
   this.SetMaskPoints=SetR3SURFA_MaskPoints;
   this.GetCog=GetR3SURFA_Cog;
   this.GetParent=GetR3SURFA_Parent;
   this.SetParent=SetR3SURFA_Parent;
   this.GetTrim=GetR3SURFA_Trim;
   this.SetTrim=SetR3SURFA_Trim;
   this.SetInvertUVTrim=SetR3SURFA_InvertUVTrim;
   this.SetTrimOperation=SetR3SURFA_TrimOperation;
   this.GetInvertNormal=GetR3SURFA_InvertNormal;
   this.SetInvertNormal=SetR3SURFA_InvertNormal;
   this.GetComplexity=GetR3SURFA_Complexity;
}

r3Surface.prototype=new r3Frsurface;
// r3surf.h_H